/**
 * MadiChat HTTP 请求模块
 * 封装与后端API交互的方法
 */


// 创建axios实例
const api = axios.create({
  baseURL: 'http://127.0.0.1:8080/chat-api', // API基础路径
  timeout: 30000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
});

// 请求拦截器 - 添加token到请求头
api.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token');
    if (token) {
      config.headers['Authorization'] = `${token}`;
    }
    return config;
  },
  error => {
    return Promise.reject(error);
  }
);

// 响应拦截器 - 判断请求是否成功
api.interceptors.response.use(
  response => {
    const data = response.data;
    // 如果返回的success为false，说明业务逻辑出错
    if (data && data.success === false) {
      // 特殊处理权限错误码E21005
      if (data.errCode === 'E21005') {
        // 清除本地token
        localStorage.removeItem('token');
        // 重定向到登录页面
        window.location.href = '/index.html';
      }
      return Promise.reject(data.message || '请求失败');
    }
    return response;
  },
  error => {
    // 处理网络错误或服务器错误
    if (error.response && error.response.data && error.response.data.errCode === 'E21005') {
      // 清除本地token
      localStorage.removeItem('token');
      // 重定向到登录页面
      window.location.href = '/index.html';
    }
    return Promise.reject(error);
  }
);

/**
 * 用户登录
 * @param {string} phone - 用户手机号
 * @param {string} password - 用户密码
 * @returns {Promise} - 返回包含登录结果的Promise对象
 */
export function login(phone, password) {
  try {
    const response = api.post('/login', {
      phone: phone,
      password: password
    });
    return response;
  } catch (error) {
    console.error('登录失败:', error);
    throw error;
  }
}

/**
 * 获取当前用户的会话列表
 * @param {number} page - 页码，默认为1
 * @param {number} pageSize - 每页数量，默认为10
 * @returns {Promise} - 返回包含会话列表的Promise对象
 */
export function getUserSessions(page = 1, pageSize = 10) {
  try {
    const response = api.get('/chatsession', {
      params: { page, pageSize }
    });
    return response;
  } catch (error) {
    console.error('获取会话列表失败:', error);
    throw error;
  }
}

/**
 * 获取会话的历史消息
 * @param {string} sessionId - 会话ID
 * @param {number} page - 页码，默认为0
 * @param {number} size - 每页数量，默认为10
 * @returns {Promise} - 返回包含历史消息的Promise对象
 */
export function getChatMessages(sessionId, page = 0, size = 10) {
  try {
    const response = api.get(`/chatsession/${sessionId}/message`, {
      params: { page, size }
    });
    return response;
  } catch (error) {
    console.error('获取历史消息失败:', error);
    throw error;
  }
}

/**
 * 删除会话
 * @param {string} sessionId - 会话ID
 * @returns {Promise} - 返回包含删除结果的Promise对象
 */
export function deleteSession(sessionId) {
  try {
    const response = api.delete(`/chatsession/${sessionId}`);
    return response;
  } catch (error) {
    console.error('删除会话失败:', error);
    throw error;
  }
}

/**
 * 发送聊天消息并处理流式响应
 * @param {FormData} formData - 包含消息内容的FormData对象
 * @param {Object} callbacks - 回调函数对象
 * @param {Function} callbacks.onThinking - 思考过程回调，参数为思考内容
 * @param {Function} callbacks.onContent - 内容更新回调，参数为新内容
 * @param {Function} callbacks.onDone - 完成回调，参数为完成信息
 * @param {Function} callbacks.onError - 错误回调，参数为错误信息
 * @returns {Promise} - 返回一个Promise对象
 */
export async function sendChatMessage(formData, callbacks = {}) {
  const { onThinking, onContent, onDone, onError } = callbacks;
  
  try {
    // 由于axios不直接支持流式响应处理，这里使用fetch API
    const apiUrl = api.defaults.baseURL + '/chat/message';
    
    const response = await fetch(apiUrl, {
      method: 'POST',
      body: formData,
      headers: {
        'Authorization': localStorage.getItem('token')
      }
    });
    
    // 检查响应是否成功
    if (!response.ok) {
      throw new Error(`网络请求失败: ${response.status} ${response.statusText}`);
    }
    
    // 获取响应的reader
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    
    let buffer = '';
    let fullContent = '';
    
    // 读取流数据
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      // 解码二进制数据
      buffer += decoder.decode(value, { stream: true });
      
      // 处理SSE格式的数据
      const lines = buffer.split('\n\n');
      buffer = lines.pop() || '';
      
      for (const line of lines) {
        if (line.trim() === '') continue;
        
        try {
          const msg = JSON.parse(line.replace('data:', ''));
          const eventType = msg.event;
          const data = msg.content;
          
          switch (eventType) {
            case 'thinking':
              if (onThinking) onThinking(data);
              break;
            case 'content':
              fullContent += data;
              if (onContent) onContent(data, fullContent);
              break;
            case 'done':
              if (onDone) onDone(data, fullContent);
              return { success: true, data: { content: fullContent, metadata: data } };
          }
        } catch (parseError) {
          console.error('解析SSE数据失败:', parseError, line);
        }
      }
    }
    
    return { success: true, data: { content: fullContent } };
  } catch (error) {
    console.error('发送聊天消息失败:', error);
    if (onError) onError(error.message);
    throw error;
  }
}

/**
 * 更新会话信息
 * @param {string} sessionId - 会话ID
 * @param {string} title - 新的会话标题
 * @returns {Promise} - 返回包含更新结果的Promise对象
 */
export function updateSession(sessionId, title) {
  try {
    const response = api.put(`/chatsession/${sessionId}`, {
      title: title
    });
    return response;
  } catch (error) {
    console.error('更新会话信息失败:', error);
    throw error;
  }
}
